package com.wzl.mixed.controller;

import com.wzl.common.VkPublicResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * jdk1.8新特性使用
 *
 * @author weizhongli
 * @since 1.0, 2022/11/19 11:12
 */
@Slf4j
@RestController
@RequestMapping("/jdk8")
public class MpJDK8Controller {

    /**
     * lamda表达式使用
     * lambda表达式本质上是一段匿名内部类，也可以是一段可以传递的代码
     */
    public VkPublicResponse lamda(){
        VkPublicResponse vkPublicResponse = new VkPublicResponse();

        //匿名内部类
        Comparator<Integer> comparator1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return 0;
            }
        };
        TreeSet<Integer> treeSet1 = new TreeSet<>(comparator1);

        //使用lambda表达式
        Comparator<Integer> comparator2 = (o1, o2) -> 0;
        TreeSet<Integer> treeSet2 = new TreeSet<>(comparator2);
        return vkPublicResponse;
    }

    /**
     * Stream API
     *
     * Stream操作的三个步骤
     * 创建stream
     * 中间操作（过滤、map）
     * 终止操作
     */
    public static VkPublicResponse streamApi() {
        VkPublicResponse vkPublicResponse = new VkPublicResponse();

        /**
         * stream创建
         */
        //1，校验通过Collection 系列集合提供的stream()或者paralleStream()
        ArrayList<Object> list = new ArrayList<>();
        list.add(111);
        list.add(222);
        list.add(333);
        Stream<Object> stream = list.stream();
        //2，通过Arrays的静态方法stream()获取数组流
        String[] strings = new String[10];
        Stream<String> stream1 = Arrays.stream(strings);
        //3,通过Stream类中的静态方法of
        Stream<String> stream2 = Stream.of("aa", "bb", "cc");
        //4,创建无限流----迭代
        Stream<Integer> stream3 = Stream.iterate(0, (x) -> x + 2);
        //5,生成
        Stream<Double> stream4 = Stream.generate(() -> Math.random());

        /**
         * 中间操作（过滤，map）
         */
        //筛选，过滤，去重
        stream.filter(a -> a.equals(111))
                .limit(1)
                .skip(1)
                .distinct()
                .forEach(System.out::println);

        //生成新的流 通过map映射
        stream.map((e) -> e.equals(111))
                .forEach(System.out::println);

        //自然排序  定制排序
        stream.sorted((e1,e2) -> {
                if(e1.equals(e2)){
                    return 0;
                } else {
                    return 0;
                }
                })
                .forEach(System.out::println);

        /**
         * 终止操作
         */
            /**
             *      查找和匹配
             *          allMatch-检查是否匹配所有元素
             *          anyMatch-检查是否至少匹配一个元素
             *          noneMatch-检查是否没有匹配所有元素
             *          findFirst-返回第一个元素
             *          findAny-返回当前流中的任意元素
             *          count-返回流中元素的总个数
             *          max-返回流中最大值
             *          min-返回流中最小值
             */
        boolean b = stream.allMatch(e -> e.equals(111));
        Optional<Object> first = stream.findFirst();
        Optional<Object> any = stream.findAny();
        long count = stream.count();
        Optional<Object> max = stream.max((e1, e2) -> Double.compare(e1.hashCode(), e2.hashCode()));

        //collect操作：Collect-将流转换为其他形式，接收一个Collection接口的实现，用于给Stream中元素做汇总的方法
        List<Boolean> list1 = stream.map(e -> e.equals(111)).collect(Collectors.toList());
        list1.stream().forEach(System.out::println);

        return vkPublicResponse;
    }

}